home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / FWDCMD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-06  |  23.4 KB  |  1,022 lines
  1. #include "global.h"
  2. #include "ctype.h"
  3. #include "files.h"
  4. #include <time.h>
  5. #include "bm.h"
  6. #include "cmdparse.h"
  7.  
  8. #if !defined(_lint)
  9. static char rcsid[] OPTIONAL = "$Id: fwdcmd.c,v 1.20 1997/09/07 00:31:16 root Exp root $";
  10. #endif
  11.  
  12. int UtcOffset = 0;
  13. int BIDuknos = 0;
  14.  
  15. #ifdef MBFWD
  16. extern const char *continents[];
  17. #define numcontinents 19
  18.  
  19. #ifdef ALTERBID
  20. int chkBidAltered = 1;
  21. int holdBidAltered = 1;
  22. #endif
  23. int MbBID = 0;
  24. int MbMID = 1;
  25. char *BIDsuffix;
  26. int MbRSTYLE = 0;
  27. char *Mbqth = NULLCHAR;
  28. char *Mbzip = NULLCHAR;
  29. char *Mbfwdinfo = NULLCHAR;
  30. char *Mbhaddress = NULLCHAR;
  31. int Mtrace = 0;
  32. int FWDareatrace = 1;
  33. #ifdef XFWD
  34. int MXfwd = 0;
  35. int Xtrace = 0;
  36. #endif
  37. #ifdef FBBFWD
  38. int FBBtrace = 0;
  39. int Mfbb = 0;
  40. #endif
  41. #ifdef FBBCMP
  42. int Mfbbcmp = 0;
  43. #endif
  44. int Mbsmtptoo = 0;
  45. char *mbxRCall;
  46. int FWDctlz = 1;
  47. char FWDCall[AXALEN];
  48. int FWDmode = 1, FWDpersonal = 1, FWDbulletins = 1, FWDreverse = 1, FWDinreverse = 1;
  49. int FWDminidle = 30;
  50. int FWDlimittime = 0;
  51. int SYSOPprotect = 1;
  52. static int TAPRspec = 1;
  53.  
  54.  
  55. extern void ReadFwdBbs (void);
  56. extern void updateFwd (char *who, char *area,long bid,long size);
  57. extern int dostr (int argc,char *argv[],const char *cmdstr,const char *label, char **str);
  58. extern int forwardreset (int argc,char *argv[],void *p);
  59. extern void forwardingSummary (void);
  60. extern char *mbxtime (char *line);
  61. extern void fwdproc (int, void *, void *);
  62. extern void checkforALTs (void);
  63.  
  64. #ifdef ALTERBID
  65. static int dombalterbid (int argc,char *argv[],void *p);
  66. static int dombalterhold (int argc,char *argv[],void *p);
  67. #endif
  68. static int dofwdreload (int argc,char *argv[],void *p);
  69. static int dofwdbid (int argc,char *argv[],void *p);
  70. static int dobidsuffix (int argc,char *argv[],void *p);
  71. static int dobiduknos (int argc,char *argv[],void *p);
  72. static int dombutc (int argc,char *argv[],void *p);
  73. static int dombmid (int argc,char *argv[],void *p);
  74. static int dombrsample (int argc,char *argv[],void *p);
  75. static int dombrstyle (int argc,char *argv[],void *p);
  76. static int dombqth (int argc,char *argv[],void *p);
  77. static int dombzipcode (int argc,char *argv[],void *p);
  78. static int dombfwdinfo (int argc,char *argv[],void *p);
  79. static int dombhaddress (int argc,char *argv[],void *p);
  80. static int dombtapr (int argc,char *argv[],void *p);
  81. static int dombtrace (int argc,char *argv[],void *p);
  82. #if defined(XFWD) || defined(FBBFWD)
  83. static int doareatrace (int argc,char *argv[],void *p);
  84. #endif
  85. static void fwdqueuearea (char *bbs, char *area);
  86. static int dofwdqueue (int argc,char *argv[],void *p);
  87. #ifdef FBBFWD
  88. static int dofbbtrace (int argc,char *argv[],void *p);
  89. #endif
  90. static int dombsubchannel (int argc,char *argv[],void *p);
  91. static int dombsysopprotect (int argc,char *argv[],void *p);
  92. static int dombsmtptoo (int argc,char *argv[],void *p);
  93. static int dombrcall (int argc,char *argv[],void *p);
  94. static int domycall (int argc,char *argv[],void *p);
  95. static int dofwdmode (int argc,char *argv[],void *p);
  96. static int dopersonal (int argc,char *argv[],void *p);
  97. static int doactive (int argc,char *argv[],void *p);
  98. static int dolaston (int argc,char *argv[],void *p);
  99. static int dominidle (int argc,char *argv[],void *p);
  100. static int dolimittime (int argc,char *argv[],void *p);
  101. static int dobulletins (int argc,char *argv[],void *p);
  102. static int doreverse (int argc,char *argv[],void *p);
  103. static int doinreverse (int argc,char *argv[],void *p);
  104. static int dosummary (int argc,char *argv[],void *p);
  105. static int dofwdstatus (int argc,char *argv[],void *p);
  106. static int doctlz (int argc,char *argv[],void *p);
  107. int dombkickone (int argc,char *argv[],void *p);
  108. int doforward (int argc,char *argv[],void *p);
  109. #ifdef FBBFWD
  110. #ifdef FBBCMP
  111. static int dofbbcmpstyle (int argc,char *argv[],void *p);
  112. #endif
  113. static int dofbbstyle (int argc,char *argv[],void *p);
  114. #endif
  115. #ifdef XFWD
  116. static int doxstyle (int argc,char *argv[],void *p);
  117. static int doxtrace (int argc,char *argv[],void *p);
  118. #endif
  119.  
  120. #ifdef CATALOG
  121. #include "catalog.h"
  122.  
  123. #define CAT fwdcmd_catalog
  124.  
  125. #define LASTCompleted    __STR(0)
  126. #define enabled        __STR(1)
  127. #define tapr1        __STR(2)
  128. #define tapr2        __STR(3)
  129. #define personal    __STR(4)
  130. #define bulletins    __STR(5)
  131. #define FBBstyle    __STR(6)
  132. #define FBBcompressed    __STR(7)
  133. #define usectlz        __STR(8)
  134. #define reverseout    __STR(9)
  135. #define reversein    __STR(10)
  136. #define activesessions    __STR(11)
  137. #define originalBID    __STR(12)
  138. #define localUTC    __STR(13)
  139. #define localMID    __STR(14)
  140. #define W0RLIstyle    __STR(15)
  141. #define qthusage    __STR(16)
  142. #define usagezipcode    __STR(17)
  143. #define usagefwdinfo    __STR(18)
  144. #define usagehaddr    __STR(19)
  145. #define tapr3        __STR(20)
  146. #define tapr4        __STR(21)
  147. #define fwdtraceflag    __STR(22)
  148. #define FBBtraceflag    __STR(23)
  149. #define subchanneldata    __STR(24)
  150. #define usagesubchannel    __STR(25)
  151. #define validsubchannels __STR(26)
  152. #define maxonsubchannel    __STR(27)
  153. #define forwardSMTP    __STR(28)
  154. #define uknosBID    __STR(29)
  155.  
  156.  
  157. #else    /* CATALOG */
  158. static const char LASTCompleted[] = "\nLast completed forwarding sessions:\n";
  159. static const char enabled[] = "Forwarding mode";
  160. static const char tapr1[] = "Make haddress conform to TAPR X.3.4 specification";
  161. static const char tapr2[] =
  162.     "Unless you *MUST*, PLEASE use a haddress that conforms to the X.3.4 spec!\n"
  163.      "The big losers when you *DON'T* are the Internet gateway SYSOPS!\n\007";
  164. static const char personal[] = "Forwarding Personal Messages";
  165. static const char bulletins[] = "Forwarding Bulletins";
  166. static const char FBBstyle[] = "FBB-style forwarding";
  167. static const char FBBcompressed[] = "FBB-style compression forwarding";
  168. static const char usectlz[] = "Use ^Z intead of /EX to end messages when forwarding";
  169. static const char reverseout[] = "Outgoing Reverse Forwarding Enabled";
  170. static const char reversein[] = "Incoming Reverse Forwarding Enabled";
  171. static const char activesessions[] = "\nActive Forwarding Sessions:\n";
  172. static const char originalBID[] = "Original BID in R: lines";
  173. static const char localUTC[] = "Local Time is UTC";
  174. static const char localMID[] = "Local MID in R: lines";
  175. static const char W0RLIstyle[] = "W0RLI style R: lines";
  176. static const char qthusage[] = "Usage: forward qth <your qth> || \"<your qth, state>\"\n";
  177. static const char usagezipcode[] = "Usage: forward zipcode <your zip>\n";
  178. static const char usagefwdinfo[] = "Usage: forward fwdinfo \"<your R:-line [info]>\"\n";
  179. static const char usagehaddr[] = "Usage: forward haddress <your H-address (without call)>\n";
  180. static const char tapr3[] = "Sorry, but that is not a proper haddress. The continent must be 4-characters.\n";
  181. static const char tapr4[] = 
  182.     "The selected haddress does not adhere to TAPR X.3.4 recommendation. :-(\n"
  183.     "The sooner we all use 4-character continents, the better\n\007";
  184. static const char fwdtraceflag[] = "Forward trace flag";
  185. static const char FBBtraceflag[] = "FBB Forwarding trace flag";
  186. static const char subchanneldata[] = "  Subchannel %2d: Maximum Fwds - %2d, Currently - %2d";
  187. static const char usagesubchannel[] = "Usage: forward subchannel channel# [maxfwds [description]]\n";
  188. static const char validsubchannels[] = "Valid subchannel numbers are 0 through %d\n";
  189. static const char maxonsubchannel[] = "Maximum Forwarding Sessions on Subchannel %d";
  190. static const char forwardSMTP[] = "Forward to PBBS w/SMTP headers";
  191. static const char uknosBID[] = "Use UKNOS-compatible PBBS bids (xxx_call@hamradio)";
  192. #endif /* CATALOG */
  193.  
  194. static const char strCR[] = "%s\n";
  195. static const char sessstr[] = "     %-9s - %sForwarding\n";
  196. static const char reversestr[] = "Reverse ";
  197.  
  198.  
  199. static struct cmds FWDcmds[] = {
  200.     { "active",    doactive,    0,    0,    NULLCHAR },
  201. #ifdef ALTERBID
  202.     { "alteredbids",dombalterbid,    0,    0,    NULLCHAR },
  203.     { "alteredhold",dombalterhold,    0,    0,    NULLCHAR },
  204. #endif
  205. #if defined(XFWD) || defined(FBBFWD)
  206.     { "areatrace",    doareatrace,    0,    0,    NULLCHAR },
  207. #endif
  208.     { "bid",    dofwdbid,    0,     0,    NULLCHAR },
  209.     { "bidsuffix",    dobidsuffix,    0,     0,    NULLCHAR },
  210.     { "biduknos",    dobiduknos,    0,     0,    NULLCHAR },
  211.     { "bulletins",    dobulletins,    0,    0,    NULLCHAR },
  212.     { "ctlz",    doctlz,        0,    0,    NULLCHAR },
  213. #ifdef FBBFWD
  214. #ifdef FBBCMP
  215.     { "fbb-compression",dofbbcmpstyle,0,    0,    NULLCHAR },
  216. #endif
  217.     { "fbb-style",    dofbbstyle,    0,    0,    NULLCHAR },
  218.     { "fbbtrace",    dofbbtrace,    0,    0,    NULLCHAR },
  219. #endif
  220.     { "fwdinfo",     dombfwdinfo,    0,    0,    NULLCHAR },
  221.     { "haddress",    dombhaddress,    0,    0,    NULLCHAR },
  222.     { "inreverse",    doinreverse,    0,    0,    NULLCHAR },
  223.     { "kick",    dombkick,    0,     0,    NULLCHAR },
  224.     { "kickone",    dombkickone,    2048,     2,    "forward kickone <bbs> [poll | export]" },
  225.     { "laston",    dolaston,    0,    0,    NULLCHAR },
  226.     { "limittime",    dolimittime,    0,    0,    NULLCHAR },
  227.     { "mid",    dombmid,    0,    0,    NULLCHAR },
  228.     { "minidle",    dominidle,    0,    0,    NULLCHAR },
  229.     { "mode",    dofwdmode,        0,    0,    NULLCHAR },
  230.     { "mycall",    domycall,    0,    0,    NULLCHAR },
  231.     { "personal",    dopersonal,    0,    0,    NULLCHAR },
  232.     { "qth",    dombqth,    0,    0,    NULLCHAR },
  233.     { "queue",    dofwdqueue,    0,    3,    "forward queue <bbs> <area | all>"},
  234.     { "rcall",    dombrcall,    0,    0,    NULLCHAR },
  235.     { "reload",    dofwdreload,    0,    0,    NULLCHAR },
  236.     { "reset",    forwardreset,    0,    0,    NULLCHAR },
  237.     { "reverse",    doreverse,    0,    0,    NULLCHAR },
  238.     { "rsample",    dombrsample,    0,    0,    NULLCHAR },
  239.     { "rstyle",    dombrstyle,    0,    0,    NULLCHAR },
  240.     { "summary",    dosummary,    0,    0,    NULLCHAR },
  241.     { "smtptoo",    dombsmtptoo,    0,    0,    NULLCHAR },
  242.     { "status",    dofwdstatus,    0,    0,    NULLCHAR },
  243.     { "subchannel",    dombsubchannel,    0,    0,    NULLCHAR },
  244.     { "sysopprotect",dombsysopprotect,0,    0,    NULLCHAR },
  245.     { "tapr",    dombtapr,    0,    0,    NULLCHAR },
  246.     { "timer",    dombtimer,    0,    0,    NULLCHAR },
  247.     { "trace",    dombtrace,    0,    0,    NULLCHAR },
  248.     { "utc",    dombutc,    0,    0,    NULLCHAR },
  249. #ifdef XFWD
  250.     { "x-style",    doxstyle,    0,    0,    NULLCHAR },
  251.     { "xtrace",    doxtrace,    0,    0,    NULLCHAR },
  252. #endif
  253.     { "zipcode",    dombzipcode,    0,    0,    NULLCHAR },
  254.     { NULLCHAR,    NULL,        0,    0,    NULLCHAR }
  255. };
  256.  
  257.  
  258.  
  259.  
  260. int
  261. doforward(argc,argv,p)
  262. int argc;
  263. char *argv[];
  264. void *p;
  265. {
  266.     return subcmd(FWDcmds,argc,argv,p);
  267. }
  268.  
  269.  
  270. int
  271. dombkickone(argc,argv,p)
  272. int argc;
  273. char *argv[];
  274. void *p OPTIONAL;
  275. {
  276. int poll = 0;
  277.  
  278.     if (argc > 2)    {
  279.         if (tolower(argv[2][0]) == 'p')
  280.             poll = 1;
  281.         else if (tolower(argv[2][0]) == 'e')
  282.             poll = 2;
  283.     }
  284.     checkforALTs ();
  285.     (void) forwardreset(0, NULLCHARP, 0);
  286.     fwdproc (poll, argv[1], (void *)0);
  287.     return 0;
  288. }
  289.  
  290.  
  291. static int
  292. dofwdmode(argc,argv,p)
  293. int argc;
  294. char *argv[];
  295. void *p OPTIONAL;
  296. {
  297.     return setint(&FWDmode, enabled, argc, argv);
  298. }
  299.  
  300.  
  301. static int
  302. dominidle(argc,argv,p)
  303. int argc;
  304. char *argv[];
  305. void *p OPTIONAL;
  306. {
  307.     return setint(&FWDminidle, "Default Minimum idle time (in secs) between fwding to same station", argc, argv);
  308. }
  309.  
  310.  
  311. static int
  312. dolimittime(argc,argv,p)
  313. int argc;
  314. char *argv[];
  315. void *p OPTIONAL;
  316. {
  317.     return setint(&FWDlimittime, "Default Maximum time (in minutes) for a fwding session", argc, argv);
  318. }
  319.  
  320.  
  321. static int
  322. dofwdreload(argc,argv,p)
  323. int argc OPTIONAL;
  324. char *argv[] OPTIONAL;
  325. void *p OPTIONAL;
  326. {
  327.     Numfwds = 0;        /* force a full reload */
  328.     ReadFwdBbs ();
  329.     tprintf ("The list of BBSs in the forward.bbs file has been reloaded\n");
  330.     return 0;
  331. }
  332.  
  333.  
  334. static int
  335. dombtapr(argc,argv,p)
  336. int argc;
  337. char *argv[];
  338. void *p OPTIONAL;
  339. {
  340. int retval;
  341.  
  342.     retval = setbool(&TAPRspec, tapr1, argc, argv);
  343.     if (!TAPRspec)
  344.         tputs (tapr2);
  345.     return (retval);
  346. }
  347.  
  348.  
  349. static int
  350. dombsysopprotect(argc,argv,p)
  351. int argc;
  352. char *argv[];
  353. void *p OPTIONAL;
  354. {
  355.     return setbool(&SYSOPprotect, "Protect 'SYSOP' area from forward deletion", argc, argv);
  356. }
  357.  
  358.  
  359. static int
  360. dopersonal(argc,argv,p)
  361. int argc;
  362. char *argv[];
  363. void *p OPTIONAL;
  364. {
  365.     return setbool(&FWDpersonal, personal, argc, argv);
  366. }
  367.  
  368.  
  369. static int
  370. dobulletins(argc,argv,p)
  371. int argc;
  372. char *argv[];
  373. void *p OPTIONAL;
  374. {
  375.     return setbool(&FWDbulletins, bulletins, argc, argv);
  376. }
  377.  
  378.  
  379. #ifdef ALTERBID
  380. int
  381. dombalterbid(argc,argv,p)
  382. int argc;
  383. char *argv[];
  384. void *p OPTIONAL;
  385. {
  386.     return setbool(&chkBidAltered,"Check for altered BIDS",argc,argv);
  387. }
  388.  
  389.  
  390.  
  391. int
  392. dombalterhold(argc,argv,p)
  393. int argc;
  394. char *argv[];
  395. void *p OPTIONAL;
  396. {
  397.     return setbool(&holdBidAltered,"Hold altered BID messages (rather than delete them)",argc,argv);
  398. }
  399. #endif
  400.  
  401.  
  402. #ifdef XFWD
  403. static int
  404. doxstyle(argc,argv,p)
  405. int argc;
  406. char *argv[];
  407. void *p OPTIONAL;
  408. {
  409.     return (setbool(&MXfwd, "X-style forwarding", argc, argv));
  410. }
  411.  
  412. static int
  413. doxtrace(argc,argv,p)
  414. int argc;
  415. char *argv[];
  416. void *p OPTIONAL;
  417. {
  418.     return setbool (&Xtrace, "X-Forwarding trace flag", argc, argv);
  419. }
  420.  
  421. #endif
  422.  
  423.  
  424. #if defined(XFWD) || defined(FBBFWD)
  425. static int
  426. doareatrace(argc,argv,p)
  427. int argc;
  428. char *argv[];
  429. void *p OPTIONAL;
  430. {
  431.     return setbool (&FWDareatrace, "Display area scan in traces flag", argc, argv);
  432. }
  433. #endif
  434.  
  435.  
  436.  
  437. #ifdef FBBFWD
  438. static int
  439. dofbbstyle(argc,argv,p)
  440. int argc;
  441. char *argv[];
  442. void *p OPTIONAL;
  443. {
  444. register int rc;
  445.  
  446.     rc = setbool(&Mfbb, FBBstyle, argc, argv);
  447. #ifdef FBBCMP
  448.     if((!rc) && (!Mfbb))    /* Successful */
  449.         Mfbbcmp = FALSE;
  450. #endif
  451.     return rc;
  452. }
  453.  
  454. #ifdef FBBCMP
  455. static int
  456. dofbbcmpstyle(argc,argv,p)
  457. int argc;
  458. char *argv[];
  459. void *p OPTIONAL;
  460. {
  461. register int rc;
  462.  
  463.     rc = setbool(&Mfbbcmp, FBBcompressed, argc, argv);
  464.     if((!rc) && (Mfbbcmp))    /* Successful */
  465.         Mfbb = TRUE;
  466.     return rc;
  467. }
  468. #endif    /* FBBCMP */
  469. #endif    /* FBBFWD */
  470.  
  471.  
  472. static int
  473. doctlz(argc,argv,p)
  474. int argc;
  475. char *argv[];
  476. void *p OPTIONAL;
  477. {
  478.     return setbool(&FWDctlz, usectlz, argc, argv);
  479. }
  480.  
  481. static int
  482. doreverse(argc,argv,p)
  483. int argc;
  484. char *argv[];
  485. void *p OPTIONAL;
  486. {
  487.     return setbool(&FWDreverse, reverseout, argc, argv);
  488. }
  489.  
  490. static int
  491. doinreverse(argc,argv,p)
  492. int argc;
  493. char *argv[];
  494. void *p OPTIONAL;
  495. {
  496.     return setbool(&FWDinreverse, reversein, argc, argv);
  497. }
  498.  
  499. /* Display or change our AX.25 address for forwarding */
  500. static int
  501. domycall(argc,argv,p)
  502. int argc;
  503. char *argv[];
  504. void *p OPTIONAL;
  505. {
  506. char tmp[AXBUF];
  507.  
  508.     if(argc < 2){
  509.         tprintf(strCR,pax25(tmp,FWDCall));
  510.         return 0;
  511.     }
  512.     if(setcall(FWDCall,argv[1]) == -1)    {
  513.         if (!*argv[1])
  514.             *FWDCall = 0;
  515.         return -1;
  516.     }
  517.     return 0;
  518. }
  519.  
  520. static int
  521. dosummary(argc,argv,p)
  522. int argc OPTIONAL;
  523. char *argv[] OPTIONAL;
  524. void *p OPTIONAL;
  525. {
  526.     forwardingSummary();
  527.     return 0;
  528. }
  529.  
  530. static int
  531. dofwdstatus(argc,argv,p)
  532. int argc OPTIONAL;
  533. char *argv[] OPTIONAL;
  534. void *p OPTIONAL;
  535. {
  536.     (void) dofwdmode (0, 0, 0);
  537.     (void) dombsysopprotect (0, 0, 0);
  538.     (void) dobulletins (0, 0, 0);
  539.     (void) dopersonal (0, 0, 0);
  540.     (void) doreverse (0, 0, 0);
  541.     (void) doinreverse (0, 0, 0);
  542.     (void) dombtrace (0, 0, 0);
  543. #if defined(XFWD) || defined(FBBFWD)
  544.     (void) doareatrace (0, 0, 0);
  545. #endif
  546. #ifdef FBBFWD
  547.     (void) dofbbtrace (0, 0, 0);
  548.     (void) dofbbstyle(0, 0, 0);
  549. #endif
  550. #ifdef FBBCMP
  551.     (void) dofbbcmpstyle(0, 0, 0);
  552. #endif
  553. #ifdef XFWD
  554.     (void) doxtrace (0, 0, 0);
  555.     (void) doxstyle(0, 0, 0);
  556. #endif
  557.     (void) doactive (0, 0, 0);
  558.     return (0);
  559. }
  560.  
  561.  
  562. static int
  563. doactive(argc,argv,p)
  564. int argc OPTIONAL;
  565. char *argv[] OPTIONAL;
  566. void *p OPTIONAL;
  567. {
  568. int i, first = 0;
  569.  
  570.     /* give forwarding in progress report */
  571.     for(i = 0; i < NUMMBX; ++i)    {
  572.         if(Mbox[i] == NULLMBX)
  573.             continue;
  574.         if ((Mbox[i]->state == MBX_FORWARD) || (Mbox[i]->state == MBX_REVFWD))    {
  575.             if (!first)    {
  576.                 tputs (activesessions);
  577.                 first = 1;
  578.             }
  579.             tprintf (sessstr, Mbox[i]->name, (Mbox[i]->state == MBX_REVFWD) ? reversestr : "");
  580.         }
  581.     }
  582.     return (0);
  583. }
  584.  
  585.  
  586. static int
  587. dolaston(argc,argv,p)
  588. int argc OPTIONAL;
  589. char *argv[] OPTIONAL;
  590. void *p OPTIONAL;
  591. {
  592. int i;
  593.  
  594.     /* give last forwarding time */
  595.     tputs (LASTCompleted);
  596.     for (i = 0; i < Numfwds; i++)    {
  597.         tprintf ("\t%-9s - ", MyFwds[i].name);
  598.         if (MyFwds[i].laston)
  599.             tputs (ptime(&MyFwds[i].laston));
  600.         else
  601.             tputs ("(none)\n");
  602.     }
  603.     return (0);
  604. }
  605.  
  606.  
  607. static int
  608. dofwdbid(argc,argv,p)
  609. int argc;
  610. char *argv[];
  611. void *p OPTIONAL;
  612. {
  613.     return setbool(&MbBID, originalBID, argc, argv);
  614. }
  615.  
  616.  
  617.  
  618. static int
  619. dobiduknos(argc,argv,p)
  620. int argc;
  621. char *argv[];
  622. void *p OPTIONAL;
  623. {
  624.     return setbool(&BIDuknos, uknosBID, argc, argv);
  625. }
  626.  
  627.  
  628.  
  629. static int
  630. dobidsuffix(argc,argv,p)
  631. int argc;
  632. char *argv[];
  633. void *p OPTIONAL;
  634. {
  635.     (void) dostr (argc,argv,"forward","bidsuffix",&BIDsuffix);
  636.     if (BIDsuffix)    {
  637.         rip(BIDsuffix);
  638.         (void) strupr(BIDsuffix);
  639.     }
  640.     return 0;
  641. }
  642.  
  643.  
  644. /*Set the difference between Local time, and UTC !*/
  645. static int
  646. dombutc(argc,argv,p)
  647. int argc;
  648. char *argv[];
  649. void *p OPTIONAL;
  650. {
  651.     if(argc < 2) {
  652.         tputs(localUTC);
  653.         if(UtcOffset == 0)
  654.             tputc('\n');
  655.         else {
  656.             if(UtcOffset > 0)
  657.                 tputc('+');
  658.             tprintf("%d\n",UtcOffset);
  659.         }
  660.         return 0;
  661.     }
  662.     UtcOffset = atoi(argv[1]);
  663.     return 0;
  664. }
  665.  
  666.  
  667. static int
  668. dombmid(argc,argv,p)
  669. int argc;
  670. char *argv[];
  671. void *p OPTIONAL;
  672. {
  673.     return setbool(&MbMID, localMID, argc, argv);
  674. }
  675.  
  676.  
  677.  
  678. int
  679. dombrsample(argc,argv,p)
  680. int argc OPTIONAL;
  681. char *argv[] OPTIONAL;
  682. void *p OPTIONAL;
  683. {
  684. time_t t;
  685. char *cp, buf[40], thetime[100];
  686.  
  687.     (void) time(&t);
  688.     if (mbxRCall)
  689.         strncpy (buf, mbxRCall, 40);
  690.     else
  691.         (void) pax25(buf,Mycall);
  692.     if((cp = strpbrk(buf, DIGI_IDS)) != NULLCHAR)
  693.         *cp = '\0'; /* remove SSID */
  694.     strncpy (thetime, ptime(&t), 100);
  695.     if (!MbRSTYLE)    {
  696.         tprintf("R:%s @:%s%s%s ", mbxtime(thetime), buf, (Mbhaddress) ? "." : "",
  697.             (Mbhaddress) ? Mbhaddress : "");
  698.         if (Mbfwdinfo)
  699.             tprintf("[%s] ", Mbfwdinfo);
  700.         if (Mbqth)
  701.             tprintf("%s ", Mbqth);
  702.         if (MbMID)
  703.             tputs("#:7388 ");
  704.         if (Mbzip)
  705.             tprintf("Z:%s ", Mbzip);
  706.         if (MbBID)    {
  707.             strncpy (buf, (BIDsuffix) ? BIDsuffix : Hostname, 40);
  708.             (void) strupr (buf);
  709.             if((cp = strchr(buf,'.')) != NULLCHAR)
  710.                 *cp = '\0';
  711.             tprintf("$:7388_%s", buf);
  712.         }
  713.     } else
  714.         tprintf("R:%s 7388@%s%s%s", mbxtime(thetime), buf, (Mbhaddress) ? "." : "",
  715.             (Mbhaddress) ? Mbhaddress : "");
  716.     tputc('\n');
  717.     return 0;
  718. }
  719.  
  720.  
  721. int
  722. dombrstyle(argc,argv,p)
  723. int argc;
  724. char *argv[];
  725. void *p OPTIONAL;
  726. {
  727.     return setbool(&MbRSTYLE, W0RLIstyle, argc, argv);
  728. }
  729.  
  730.  
  731. /* Set the QTH to be used in R: line when forwarding*/
  732. static int
  733. dombqth(argc,argv,p)
  734. int argc;
  735. char *argv[];
  736. void *p OPTIONAL;
  737. {
  738.     if (argc > 2) {
  739.         tputs (qthusage);
  740.         return 0;
  741.     }
  742.  
  743.     if (argc < 2) {
  744.         if (Mbqth != NULLCHAR)
  745.             tprintf (strCR, Mbqth);
  746.     } else {
  747.         if(Mbqth != NULLCHAR)    {
  748.             free (Mbqth);
  749.             Mbqth = NULLCHAR;   /* reset the pointer */
  750.         }
  751.         if(!strlen (argv[1]))
  752.             return 0;        /* clearing the buffer */
  753.         Mbqth = strdup (argv[1]);
  754.     }
  755.     return 0;
  756. }
  757.  
  758.  
  759. /*Set the ZIP to be used in the R: line when forwarding */
  760. static int
  761. dombzipcode(argc,argv,p)
  762. int argc;
  763. char *argv[];
  764. void *p OPTIONAL;
  765. {
  766. int len;
  767.  
  768.     if (argc > 2) {
  769.         tputs (usagezipcode);
  770.         return 0;
  771.     }
  772.  
  773.     if (argc < 2) {
  774.         if (Mbzip != NULLCHAR)
  775.             tprintf (strCR, Mbzip);
  776.     } else {
  777.         len = (int) strlen (argv[1]);
  778.             if (Mbzip != NULLCHAR)    {
  779.             free (Mbzip);
  780.             Mbzip = NULLCHAR;   /* reset the pointer */
  781.         }
  782.         if (!len)
  783.             return 0;        /* clearing the buffer */
  784.         Mbzip = strdup (argv[1]);
  785.     }
  786.     return 0;
  787. }
  788.  
  789. /*Set the R: line [info] to be used when forwarding*/
  790. static int
  791. dombfwdinfo(argc,argv,p)
  792. int argc;
  793. char *argv[];
  794. void *p OPTIONAL;
  795. {
  796.     if (argc > 2) {
  797.         tputs (usagefwdinfo);
  798.         return 0;
  799.     }
  800.  
  801.     if (argc < 2) {
  802.         if (Mbfwdinfo != NULLCHAR)
  803.             tprintf (strCR, Mbfwdinfo);
  804.     } else {
  805.         if (Mbfwdinfo != NULLCHAR)    {
  806.             free (Mbfwdinfo);
  807.             Mbfwdinfo = NULLCHAR;   /* reset the pointer */
  808.         }
  809.         if(!strlen (argv[1]))
  810.             return 0;        /* clearing the buffer */
  811.         Mbfwdinfo = strdup (argv[1]);
  812.     }
  813.     return 0;
  814. }
  815.  
  816.  
  817. /*Set the hierachical address to be used in R: line when forwarding*/
  818. static int
  819. dombhaddress(argc,argv,p)
  820. int argc;
  821. char *argv[];
  822. void *p OPTIONAL;
  823. {
  824. int k;
  825. char *cp;
  826.  
  827.     if (argc > 2) {
  828.         tputs (usagehaddr);
  829.         return 0;
  830.     }
  831.  
  832.     if (argc < 2) {
  833.         if(Mbhaddress != NULLCHAR)
  834.             tprintf (strCR, Mbhaddress);
  835.     } else {
  836.         /*make sure they're lower case*/
  837.         (void) strlwr (argv[1]);
  838.         /* check for a proper, 4 character continent */
  839.         for (k = 0; k < numcontinents; k++)    {
  840.             if (((cp = strstr(argv[1], continents[k])) != NULLCHAR) && (*(cp-1) == '.') && (*(cp-5) == '.') && !cp[4])
  841.                 break;
  842.         }
  843.         if (k == numcontinents)    {
  844.             if (TAPRspec)    {
  845.                 tputs (tapr3);
  846.                 return 0;
  847.             } else
  848.                 tputs (tapr4);
  849.         }
  850.  
  851.         if (Mbhaddress != NULLCHAR)    {
  852.             free (Mbhaddress);
  853.             Mbhaddress = NULLCHAR;   /* reset the pointer */
  854.         }
  855.         if (!strlen (argv[1]))
  856.             return 0;        /* clearing the buffer */
  857.         Mbhaddress = strdup (argv[1]);
  858.         /*make sure they're upper case*/
  859.         (void) strupr (Mbhaddress);
  860.     }
  861.     return 0;
  862. }
  863.  
  864.  
  865. static int
  866. dombtrace(argc,argv,p)
  867. int argc;
  868. char *argv[];
  869. void *p OPTIONAL;
  870. {
  871.     return setbool (&Mtrace, fwdtraceflag, argc, argv);
  872. }
  873.  
  874.  
  875. #ifdef FBBFWD
  876. static int
  877. dofbbtrace(argc,argv,p)
  878. int argc;
  879. char *argv[];
  880. void *p OPTIONAL;
  881. {
  882.     return setbool (&FBBtrace, FBBtraceflag, argc, argv);
  883. }
  884. #endif
  885.  
  886.  
  887. static int
  888. dombsubchannel(argc,argv,p)
  889. int argc;
  890. char *argv[];
  891. void *p OPTIONAL;
  892. {
  893. int netnum, didheader = 0;
  894. char buf[60], *cp;
  895.  
  896.     if (argc == 1)    {
  897.         tprintf ("Total available subchannels: %-d (0-%-d)\n", NUMMBX, NUMMBX - 1);
  898.         for (netnum = 0; netnum < NUMMBX; netnum++)    {
  899.             if (subchannels[netnum].limit || subchannels[netnum].used || subchannels[netnum].description)    {
  900.                 if (!didheader)    {
  901.                     didheader = 1;
  902.                     tputs ("Subchannels defined or in use:\n");
  903.                 }
  904.                 tprintf (subchanneldata, netnum, subchannels[netnum].limit, subchannels[netnum].used);
  905.                 if (subchannels[netnum].description)
  906.                     tprintf ("  (%s)", subchannels[netnum].description);
  907.                 tputs ("\n");
  908.             }
  909.         }
  910.         if (!didheader)
  911.             tputs ("No subchannels defined or in use...\n");
  912.         return 0;
  913.     }
  914.     if (argv[1][0] == '?')    {
  915.         tputs (usagesubchannel);
  916.         return 0;
  917.     }
  918.     netnum = atoi (argv[1]);
  919.     if (netnum > NUMMBX)    {
  920.         tprintf (validsubchannels, NUMMBX - 1);
  921.         return 0;
  922.     }
  923.     if (argc > 3)    {
  924.         if (subchannels[netnum].description)    {
  925.             free (subchannels[netnum].description);
  926.             subchannels[netnum].description = NULLCHAR;
  927.         }
  928.         if (*argv[3])
  929.             subchannels[netnum].description = strdup (argv[3]);
  930.     }
  931.     sprintf (buf, maxonsubchannel, netnum);
  932.     cp = argv[1];
  933.     argv[1] = argv[2];
  934.     argv[2] = cp;
  935.     return setint(&subchannels[netnum].limit,buf,argc - 1,argv);
  936. }
  937.  
  938.  
  939. static int
  940. dombsmtptoo(argc,argv,p)
  941. int argc;
  942. char *argv[];
  943. void *p OPTIONAL;
  944. {
  945.     return setbool(&Mbsmtptoo, forwardSMTP, argc, argv);
  946. }
  947.  
  948.  
  949. static int
  950. dombrcall(argc,argv,p)
  951. int argc;
  952. char *argv[];
  953. void *p OPTIONAL;
  954. {
  955.     (void) dostr (argc,argv,"forward","rcall",&mbxRCall);
  956.     if (mbxRCall)    {
  957.         rip(mbxRCall);
  958.         (void) strupr(mbxRCall);
  959.     }
  960.     return 0;
  961. }
  962.  
  963.  
  964. static void
  965. fwdqueuearea (bbs, area)
  966. char *bbs, *area;
  967. {
  968. struct mbx *m;
  969. struct let *cmsg;
  970. int i, messages = 0;
  971. long size = 0L;
  972.  
  973.     m = (struct mbx *)callocw(1,sizeof(struct mbx));
  974.     strncpy (m->name, bbs, 20);
  975.     changearea(m,area, 0);
  976.     for (cmsg = &m->mbox[1],i = 1; i <= m->nmsgs; i++, cmsg++)
  977.         if (!(cmsg->status & BM_DELETE))    {
  978.             updateFwd (bbs, area, cmsg->bid, cmsg->size);
  979.             size += cmsg->size;
  980.             messages++;
  981.         }
  982.     (void) closenotes (m, 1);
  983.     free (m);
  984.     if (size)    {
  985.         size += 1023;
  986.         size /= 1024;
  987.     }
  988.     tprintf ("Added to forwarding queue for %s: Area '%s' - %d messages (%ldK)\n",
  989.         bbs, area, messages, size);
  990. }
  991.  
  992.  
  993. static int
  994. dofwdqueue(argc,argv,p)
  995. int argc OPTIONAL;
  996. char *argv[];
  997. void *p OPTIONAL;
  998. {
  999. struct fwdbbs *f;
  1000. int all;
  1001. struct arealist *a;
  1002.  
  1003.     f = fwdread (argv[1], Numfwds);    /* first get BBS entry */
  1004.     if (f == NULLFWDBBS)    {
  1005.         tprintf ("Invalid BBS: %s\n", argv[1]);
  1006.         return 0;
  1007.     }
  1008.     all = !stricmp (argv[2], "all");
  1009.  
  1010.     for (a = f->areas; a; a = a->next)    {
  1011.         if (all || !stricmp (argv[2], a->name))
  1012.             fwdqueuearea (f->name, a->name);
  1013.     }
  1014.  
  1015.     fwdfree (&f);
  1016.     return 0;
  1017. }
  1018.  
  1019.  
  1020.  
  1021. #endif /* MBFWD */
  1022.